package cn.peifu.hrm.service.impl;

import cn.peifu.hrm.constants.BaseConstants;
import cn.peifu.hrm.domain.CourseType;
import cn.peifu.hrm.exception.code.ErrorCode;
import cn.peifu.hrm.mapper.CourseTypeMapper;
import cn.peifu.hrm.service.ICourseTypeService;
import cn.peifu.hrm.util.AssertUtils;
import cn.peifu.hrm.vo.CrumbsVo;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author xie
 * @since 2021-08-19
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    /**
     * 将分类数据存储到Redis中
     * @return
     */
    public List<CourseType> treeDataFromRedisOrDb(){
        //查询redis中是否已经有分类
        Object data = redisTemplate.opsForValue().get(BaseConstants.RedisConstant.ALL_COURSE_TYPES);
        if(data != null){
            //如果有，直接将redis中数据返回
            return (List<CourseType>) data;
        }
        //如果没有，从mysql中查询出分类并存储到redis中，再返回
        //1.从MySQL中查询
        List<CourseType> courseTypes = super.selectList(null);
        //2.存入Redis
        redisTemplate.opsForValue().set(BaseConstants.RedisConstant.ALL_COURSE_TYPES,courseTypes);
        //3.返回查询的数据
        return courseTypes;
    }

    /**
     * 清空redis缓存
     * @param entity
     * @return
     */
    @Override
    public boolean insert(CourseType entity) {
        //新增
        boolean insert = super.insert(entity);
        // 如果新增成功，删除原数据
        if(insert){
            redisTemplate.delete(BaseConstants.RedisConstant.ALL_COURSE_TYPES);
        }
        return insert;
    }

    @Override
    public List<CourseType> loadTreeData() {
        //1.取出所有课程类型
        List<CourseType> courseTypes = treeDataFromRedisOrDb();
        HashMap<Long, CourseType> typesMap = new HashMap<>();
        for (CourseType type : courseTypes) {
            typesMap.put(type.getId(),type);
        }
        //2.第一层没有pid
        List<CourseType> firstTypes = new ArrayList<>();
        for (CourseType courseType : courseTypes) {
            if(courseType.getPid()==null || courseType.getPid().intValue()==0){
                //那么该类型是第一层类型
                firstTypes.add(courseType);
            } else {
                //否则寻找上一级类型
                CourseType parentType = typesMap.get(courseType.getPid());
                if(parentType != null){
                    parentType.getChildren().add(courseType);
                }
            }
        }
        return firstTypes;
    }

    @Override
    public List<CrumbsVo> crumbs(Long courseTypeId) {
        // 参数校验
        AssertUtils.isNull(courseTypeId, ErrorCode.CODE_204_NULL_COURSE_ID.getMessage());
        // 根据当前id查询自己
        CourseType courseType = super.selectById(courseTypeId);
        AssertUtils.isNull(courseType,ErrorCode.CODE_204_NULL_COURSE_ID.getMessage());
        // 拿到path，以\\.进行分割得到上级数组
        String[] path = courseType.getPath().split("\\.");
        List<CrumbsVo> crumbsVos = new ArrayList<>(path.length);
        // 遍历数组
        for (String id : path) {
            CrumbsVo crumbsVo = new CrumbsVo();
            CourseType type = super.selectById(Long.valueOf(id));
            crumbsVo.setOwnerCourseType(type);
            if(type.getPid()!=null && type.getPid()!=0){
                EntityWrapper<CourseType> wrapper = new EntityWrapper<>();
                // 比较
                wrapper.eq("pid",type.getPid());
                List<CourseType> courseTypes = baseMapper.selectList(wrapper);
                // 显示面包屑去掉自己
                courseTypes.remove(type);
                crumbsVo.setOtherCourseTypes(courseTypes);
            }
            crumbsVos.add(crumbsVo);
        }
        return crumbsVos;
    }
}
